/**
 * Notes: 项目数据模型
 * Ver : CCMiniCloud Framework 2.0.1 ALL RIGHTS RESERVED BY cclinux0730 (wechat)
 * Date: 2023-08-30 19:20:00
 */

const BaseProjectModel = require('./base_project_model.js');
const util = require('../../../framework/helpers/util.js');
const dataUtil = require('../../../framework/helpers/data_util.js');
const timeUtil = require('../../../framework/helpers/time_util.js');
const { PROJECT_SCHEMA } = require('../constants/project_schema.js');
const cloudBase = require('../../../framework/cloud/cloud_base.js');
const Model = require('../../../framework/database/model.js');
const AppError = require('../../../framework/core/app_error.js');

class ProjectModel extends BaseProjectModel {

	// 定义核心字段列表
	static CORE_FIELDS = [
		// 系统字段
		'_id', '_pid', 'createTime', 'updateTime', 'stateTime', 'status',
		
		// 基础信息
		'model', 'projectType', 'projectTypeName', 'customerName', 
		'applicantName', 'applicantId', 'priority', 'description',
		
		// 时间字段
		'startDate', 'deadline', 'planStartDate', 'planEndDate',
		
		// 状态字段
		'level1', 'level2', 'level3', 'level4', 'fullStatusDesc',
		'completionPercentage', 'developmentStatus', 'progress',
		
		// 分支信息
		'branchId', 'branchName', 'masterBranchId',
		
		// 人员相关
		'developmentManager', 'businessManager', 'projectLead', 'projectLeadId',
		'department', 'salesperson', 'salespersonId', 'salespersonName',
		'projectManager', 'projectManagerId',
		
		// 标记字段
		'isActive', 'isOverdue',
		
		// 扩展数据字段（核心字段，但其内容为扩展字段）
		'extData'
	];

	/** 构造函数 */
	constructor() {
		super();

		// 设置集合名
		this.TABLE = 'project';

		// 字段定义 - 完全使用小驼峰命名
		this.DB_STRUCTURE = PROJECT_SCHEMA;
	}

	/**
	 * 状态字段结构定义
	 * @returns {Object} 状态字段结构
	 */
	STATUS_STRUCTURE() {
		return {
			level1: 'int|true|default=1',     // 一级状态（必填）
			level2: 'string|true|default=director', // 二级状态（必填）
			level3: 'string|false',           // 三级状态（选填）
			level4: 'string|false'            // 四级状态（选填）
		};
	}

	/**
	 * 获取状态文本映射表
	 * @returns {Object} 状态文本映射表
	 */
	getStatusTextMap() {
		return {
			level1: {
				1: '待立项',
				2: '研发中',
				3: '暂停',
				4: '测试中',
				5: '已完成',
				6: '已取消'
			},
			level2: {
				1: {
					'director': '董事长',
					'manager': '研发经理',
					'assignment': '分配'
				},
				2: {
					'design': '设计',
					'development': '开发',
					'review': '审核'
				},
				3: {
					'user': '用户原因',
					'resource': '资源原因',
					'technical': '技术原因'
				},
				4: {
					'unit': '单元测试',
					'integration': '集成测试',
					'acceptance': '验收测试'
				}
			},
			level3: {
				'hardware': '硬件',
				'software': '软件',
				'data': '资料'
			},
			level4: {
				'hardware': {
					'pcb': 'PCB',
					'component': '元器件',
					'assembly': '组装'
				},
				'software': {
					'coding': '编码',
					'debug': '调试',
					'optimization': '优化'
				}
			}
		};
	}

	// 静态集合名称
	static get CL() {
		return this.C('project');
	}

	/**
	 * 构建包含扩展字段的查询条件
	 * @param {Object} whereObj 原始查询条件
	 * @returns {Object} 处理后的查询条件
	 */
	static buildExtFieldQuery(whereObj) {
		// 如果没有查询条件，返回空对象
		if (!whereObj || Object.keys(whereObj).length === 0) {
			return {};
		}
		
		const coreQuery = {};
		const extQuery = {};
		let hasOr = false;
		
		// 特殊处理or条件
		if (whereObj.or) {
			hasOr = true;
			// 保留原始or条件，待后续处理
		}
		
		// 分离核心字段查询和扩展字段查询
		for (const key in whereObj) {
			// 跳过or条件
			if (key === 'or') continue;
			
			if (this.CORE_FIELDS.includes(key)) {
				coreQuery[key] = whereObj[key];
			} else {
				// 构建扩展字段查询条件
				extQuery[`extData.${key}`] = whereObj[key];
			}
		}
		
		// 如果有or条件，需要特殊处理
		if (hasOr && Array.isArray(whereObj.or)) {
			// 转换or条件中的扩展字段
			const newOr = whereObj.or.map(condition => {
				const newCondition = {};
				
				for (const key in condition) {
					if (this.CORE_FIELDS.includes(key)) {
						newCondition[key] = condition[key];
					} else {
						newCondition[`extData.${key}`] = condition[key];
					}
				}
				
				return newCondition;
			});
			
			// 添加处理后的or条件
			coreQuery['$or'] = newOr;
		}
		
		// 合并查询条件
		return { ...coreQuery, ...extQuery };
	}

	/**
	 * 获取项目列表
	 * @param {Object} whereObj 查询条件
	 * @param {Object} options 查询选项
	 * @returns {Promise<Object>} 查询结果
	 */
	static async getList(whereObj, options = {}) {
		console.log('[ProjectModel.getList] 开始查询, 条件:', JSON.stringify(whereObj));
		
		try {
			// 转换查询条件，支持扩展字段
			const query = this.buildExtFieldQuery(whereObj);
			console.log('[ProjectModel.getList] 转换后查询条件:', JSON.stringify(query));
			
			const COLLECTION_NAME = "plm_research_project";
			const db = cloudBase.getCloud().database();
			const collection = db.collection(COLLECTION_NAME);
			
			// 构建查询
			let dbQuery = collection.where(query);
			
			// 设置排序
			if (options.orderBy) {
				for (const key in options.orderBy) {
					dbQuery = dbQuery.orderBy(key, options.orderBy[key]);
				}
			}
			
			// 设置分页
			if (options.page && options.size) {
				const skip = (options.page - 1) * options.size;
				dbQuery = dbQuery.skip(skip).limit(options.size);
			} else if (options.size) {
				dbQuery = dbQuery.limit(options.size);
			}
			
			// 执行查询
			const result = await dbQuery.get();
			
			// 处理查询结果
			if (result && result.data) {
				// 展开每个项目的扩展字段
				const projectList = result.data.map(item => this.getFullProjectData(item));
				
				console.log('[ProjectModel.getList] 查询成功, 结果数量:', projectList.length);
				
				// 构建返回结果
				const returnData = {
					list: projectList,
					total: projectList.length
				};
				
				// 如果需要获取总数
				if (options.isTotal) {
					const countResult = await collection.where(query).count();
					returnData.total = countResult.total;
				}
				
				return returnData;
			}
			
			console.warn('[ProjectModel.getList] 查询结果为空');
			return {
				list: [],
				total: 0
			};
		} catch (error) {
			console.error('[ProjectModel.getList] 查询失败:', error);
			return {
				list: [],
				total: 0,
				error: error.message
			};
		}
	}

	/**
	 * 获取项目列表
	 * @param {Object} param0 查询参数
	 * @returns 项目列表
	 */
	static async getProjectList({ search, sortType, sortVal, page, size, status, department }) {
		let query = {};
		let orderBy = {
			'updateTime': 'desc',  // 默认按修改时间倒序
			'_id': 'desc'         // 第二排序键为ID
		};

		// 打印传入的参数
		console.log('[getProjectList] 传入参数:', {
			search, sortType, sortVal, page, size, status, department
		});

		// 状态条件
		if (status && status !== 'all') {
			query.level1 = parseInt(status);
		}

		// 部门条件
		if (department) {
			query.department = department;
		}

		// 搜索条件
		if (search) {
			query['$or'] = [
				{
					model: {
						$regex: search,
						$options: 'i'
					}
				},
				{
					projectLead: {
						$regex: search,
						$options: 'i'
					}
				}
			];
		}

		// 根据排序类型设置排序
		if (sortType) {
			switch (sortType) {
				case 'recent':
					orderBy = { 
						'updateTime': 'desc',
						'_id': 'desc'
					};
					break;
				case 'urgent':
					orderBy = { 
						'priority': 'desc', 
						'deadline': 'asc',
						'_id': 'desc'
					};
					break;
				case 'name':
					orderBy = {
						'model': 'asc',
						'_id': 'desc'
					};
					break;
				case 'deadline':
					orderBy = {
						'deadline': 'asc',
						'_id': 'desc'
					};
					break;
				case 'normal':
				default:
					orderBy = { 
						'updateTime': 'desc',
						'_id': 'desc'
					};
			}
		}

		try {
			console.log(`[getProjectList] 开始查询，条件:`, JSON.stringify(query));
			console.log(`[getProjectList] 排序条件:`, JSON.stringify(orderBy));

			// 获取总数
			let total = await this.count(query);
			console.log(`[getProjectList] 查询结果总数: ${total}`);
			
			if (total === 0) {
				console.log(`[getProjectList] 没有找到项目数据`);
				return {
					total: 0,
					list: [],
					page: page || 1,
					size: size || 20
				};
			}
			
			// 设置分页参数
			if (!page) page = 1;
			if (!size) size = 20;
			
			// 直接调用 getList 方法查询数据
			const result = await this.getList(query, '*', orderBy, page, size);
			console.log(`[getProjectList] 获取列表成功，列表大小: ${result && result.list ? result.list.length : 0}`);
			
			// 确保result有正确的结构
			if (!result) {
				return {
					total: 0,
					list: [],
					page: page,
					size: size
				};
			}
			
			// 确保list是一个数组
			if (!result.list || !Array.isArray(result.list)) {
				result.list = [];
			}
			
			// 添加总数信息
			result.total = total;
			
			console.log('[getProjectList] 过滤后的数据列表大小:', result.list.length);

			// 添加统计数据
			result.statistics = {
				total: total,
				pending: await this.count({ level1: 0 }),
				ongoing: await this.count({ level1: 1 }),
				completed: await this.count({ level1: 99 }),
				suspended: await this.count({ level1: 2 })
			};

			console.log(`[getProjectList] 返回结果:`, JSON.stringify({
				total: result.total,
				listSize: result.list.length,
				page: result.page,
				size: result.size
			}));
			
			return result;

		} catch (err) {
			console.error('[getProjectList] 获取项目列表失败:', err);
			// 返回空结果而不是抛出异常
			return {
				total: 0,
				list: [],
				page: page || 1,
				size: size || 20
			};
		}
	}

	/**
	 * 获取完整项目数据（包括将扩展字段展开到顶层）
	 * @param {Object} project 项目数据
	 * @returns {Object} 完整项目数据
	 * @static
	 */
	static getFullProjectData(project) {
		if (!project) return null;
		
		// 创建结果对象 - 保留所有核心字段
		const result = { ...project };
		
		// 如果有扩展数据，展开到顶层
		if (project.extData && typeof project.extData === 'object') {
			// 展开所有扩展字段
			for (const key in project.extData) {
				// 避免覆盖核心字段
				if (!this.CORE_FIELDS.includes(key)) {
					result[key] = project.extData[key];
				}
			}
		}
		
		return result;
	}
	
	/**
	 * 获取单个项目（静态方法）
	 * @param {string} id 项目ID
	 * @returns 项目详情
	 */
	static async getOne(id) {
		console.log('[ProjectModel.static.getOne] 开始获取项目, ID:', id);
		
		try {
			const COLLECTION_NAME = "plm_research_project";
			
			const db = cloudBase.getCloud().database();
			const collection = db.collection(COLLECTION_NAME);
			
			// 使用doc()方法直接查询单个文档，确保返回所有字段
			const result = await collection.doc(id).get();
			console.log('[ProjectModel.static.getOne] 查询结果:', JSON.stringify(result).substring(0, 300));
			
			if (result && result.data && result.data.length > 0) {
				console.log('[ProjectModel.static.getOne] 字段数量:', Object.keys(result.data[0]).length);
				console.log('[ProjectModel.static.getOne] 字段列表:', Object.keys(result.data[0]));
				
				// 展开扩展字段
				const fullProject = this.getFullProjectData(result.data[0]);
				console.log('[ProjectModel.static.getOne] 展开后字段数量:', Object.keys(fullProject).length);
				
				return fullProject;
			} else {
				console.warn('[ProjectModel.static.getOne] 找不到项目或结果为空');
				return null;
			}
		} catch (error) {
			console.error('[ProjectModel.static.getOne] 查询错误:', error);
			return null;
		}
	}

	/**
	 * 通过条件获取单个项目
	 * @param {Object} where 查询条件
	 * @returns 项目详情
	 */
	async getOne(where = {}) {
		console.log('[ProjectModel.getOne] 开始获取项目, 条件:', JSON.stringify(where));
		
		try {
			// 确保使用相同的表名
			this.TABLE = "plm_research_project";
			
			const db = cloudBase.getCloud().database();
			const collection = db.collection(this.TABLE);
			
			let result;
			if (where._id) {
				// 如果是按ID查询，使用doc方法直接获取
				result = await collection.doc(where._id).get();
			} else {
				// 使用where条件查询
				result = await collection.where(where).limit(1).get();
			}
			
			console.log('[ProjectModel.getOne] 查询结果:', JSON.stringify(result).substring(0, 300));
			
			if (result && result.data && result.data.length > 0) {
				console.log('[ProjectModel.getOne] 字段数量:', Object.keys(result.data[0]).length);
				console.log('[ProjectModel.getOne] 字段列表:', Object.keys(result.data[0]));
				
				// 展开扩展字段
				const fullProject = ProjectModel.getFullProjectData(result.data[0]);
				console.log('[ProjectModel.getOne] 展开后字段数量:', Object.keys(fullProject).length);
				
				return fullProject;
			} else {
				console.warn('[ProjectModel.getOne] 找不到项目或结果为空');
				return null;
			}
		} catch (error) {
			console.error('[ProjectModel.getOne] 查询错误:', error);
			return null;
		}
	}

	/**
	 * 插入项目数据
	 * @param {Object} data 项目数据
	 * @returns {Promise<String>} 插入的项目ID
	 */
	async insert(data) {
		// 集合名称 - 确保正确
		this.TABLE = "plm_research_project";
		
		try {
			console.log('[ProjectModel.insert] 开始插入数据，字段数:', Object.keys(data).length);
			console.log('[ProjectModel.insert] 原始字段列表:', Object.keys(data).join(', '));
			
			// 检查是否来自静态方法调用，以避免重复清洗
			let processedData;
			if (data.__fromStatic) {
				console.log('[ProjectModel.insert] 数据来自静态方法，跳过数据清洗');
				// 删除标记
				processedData = { ...data };
				delete processedData.__fromStatic;
			} else {
				// 使用修改后的clearCreateData方法预处理数据
				console.log('[ProjectModel.insert] 执行数据清洗');
				processedData = ProjectModel.clearCreateData(data);
			}
			console.log('[ProjectModel.insert] 处理后字段数:', Object.keys(processedData).length);
			
			// 添加基础系统字段
			if (!processedData._id) {
				processedData._id = this.generateId();
				console.log('[ProjectModel.insert] 生成ID:', processedData._id);
			}
			if (!processedData.createTime) processedData.createTime = Math.floor(Date.now() / 1000);
			if (!processedData.updateTime) processedData.updateTime = processedData.createTime;
			if (!processedData.stateTime) processedData.stateTime = processedData.createTime;
			
			// 数据完整性检查
			const requiredFields = ['model', 'projectType', 'customerName'];
			const missingFields = requiredFields.filter(field => !processedData[field]);
			
			if (missingFields.length > 0) {
				console.error('[ProjectModel.insert] 缺少必填字段:', missingFields.join(', '));
				throw new Error(`缺少必填字段: ${missingFields.join(', ')}`);
			}
			
			// 确保extData是对象
			if (!processedData.extData || typeof processedData.extData !== 'object') {
				processedData.extData = {};
				console.log('[ProjectModel.insert] 创建空的extData对象');
			}
			
			// 插入数据前检查并记录完整性日志
			console.log('【数据插入】数据完整性检查', {
				modelName: this.name || this.TABLE,
				hasModelField: !!processedData.model,
				fieldCount: Object.keys(processedData).length,
				timestamp: processedData.createTime,
				coreFields: Object.keys(processedData).filter(k => k !== 'extData'),
				extFields: Object.keys(processedData.extData || {})
			});
			
			// 获取数据库引用
			let db;
			try {
				db = cloudBase.getCloud().database();
				console.log('[ProjectModel.insert] 获取数据库引用成功');
			} catch (dbError) {
				console.error('[ProjectModel.insert] 获取数据库引用失败:', dbError);
				throw new Error('数据库连接失败');
			}
				
			// 获取集合引用
			let collection;
			try {
				collection = db.collection(this.TABLE);
				console.log('[ProjectModel.insert] 获取集合引用成功:', this.TABLE);
			} catch (collectionError) {
				console.error('[ProjectModel.insert] 获取集合引用失败:', collectionError);
				throw new Error('获取集合失败');
			}
				
			// 记录要插入的数据结构
				console.log('[ProjectModel.insert] 要插入的数据结构:', 
					Object.keys(processedData).map(key => {
						const value = processedData[key];
						if (typeof value === 'object' && value !== null) {
							return `${key}: [${typeof value}:${Array.isArray(value) ? 'Array' : 'Object'}]`;
						}
					return `${key}: ${typeof value === 'object' ? JSON.stringify(value) : value}`;
					}).join(', ')
				);
			
			// 简化数据，避免潜在的字段类型问题
			const safeData = {};
			for (const key in processedData) {
				if (key === 'extData') {
					safeData.extData = processedData.extData;
					continue;
				}
				
				const value = processedData[key];
				// 避免复杂对象类型，简化为基本类型
				if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
					safeData[key] = JSON.stringify(value);
				} else {
					safeData[key] = value;
				}
			}
			
			// 执行插入操作
			console.log('[ProjectModel.insert] 开始执行插入操作...');
			let result;
			try {
				result = await collection.add({
					data: safeData
				});
				console.log('[ProjectModel.insert] 插入操作执行完成:', JSON.stringify(result));
			} catch (insertError) {
				console.error('[ProjectModel.insert] 插入操作失败:', insertError);
				console.error('[ProjectModel.insert] 错误详情:', insertError);
				
				// 尝试再次插入，使用简化的数据
				console.log('[ProjectModel.insert] 尝试使用简化数据重新插入...');
				try {
					// 最简化的数据集合
					const minimalData = {
						_id: processedData._id,
						model: processedData.model,
						customerName: processedData.customerName,
						projectType: processedData.projectType,
						createTime: processedData.createTime,
						updateTime: processedData.updateTime
					};
					
					result = await collection.add({
						data: minimalData
				});
			
					console.log('[ProjectModel.insert] 简化插入成功:', JSON.stringify(result));
				} catch (retryError) {
					console.error('[ProjectModel.insert] 简化插入也失败:', retryError);
					throw new Error('数据插入失败: ' + insertError.message);
				}
			}
			
			if (!result || !result._id) {
				throw new Error('数据插入失败: 未返回ID');
			}
			
			console.log('[ProjectModel.insert] 数据插入成功，ID:', result._id);
			
				// 验证保存结果
				try {
						console.log('[ProjectModel.insert] 验证保存结果...');
					const doc = await collection.doc(result._id).get();
					if (doc && doc.data && doc.data.length > 0) {
						console.log('[ProjectModel.insert] 验证成功，保存了', Object.keys(doc.data[0]).length, '个字段');
						console.log('[ProjectModel.insert] 保存的字段列表:', Object.keys(doc.data[0]).join(', '));
						
						// 检查哪些字段丢失了
						const missingFields = [];
						for (const key of Object.keys(processedData)) {
							if (!doc.data[0].hasOwnProperty(key)) {
								missingFields.push(key);
							}
						}
						
						if (missingFields.length > 0) {
							console.warn('[ProjectModel.insert] 丢失的字段:', missingFields.join(', '));
						} else {
							console.log('[ProjectModel.insert] 所有字段都正确保存');
						}
					} else {
						console.warn('[ProjectModel.insert] 数据存在但验证返回为空');
					}
			} catch (verifyError) {
				console.warn('[ProjectModel.insert] 验证出错:', verifyError.message);
				}
				
				return result._id;
			
		} catch (err) {
			console.error('[ProjectModel.insert] 插入失败:', err);
			console.error('[ProjectModel.insert] 错误详情:', err);
					
			// 尝试记录错误
			try {
				// 移除dataMonitor的依赖
			} catch (logError) {
				console.warn('[ProjectModel.insert] 记录错误日志失败:', logError.message);
			}
			
			throw err;
		}
	}

	/**
	 * 重写count方法，适应云开发环境
	 * @param {Object} where 查询条件
	 * @returns {Object} 计数结果
	 */
	async count(where = {}) {
		console.log('[ProjectModel.count] 开始计数, 条件:', where);
		try {
			// 确保使用相同的表名
			this.TABLE = "plm_research_project";
			
			// 使用正确的集合名
			const db = cloudBase.getCloud().database();
			const collection = db.collection(this.TABLE);
			
			// 使用云开发标准的count方法
			const countResult = await collection.where(where).count();
			console.log('[ProjectModel.count] 计数结果:', countResult);
			
			// 调用者可能期望不同格式的结果，我们返回最完整的信息
			return {
				code: 0,
				total: countResult.total || 0,
				count: countResult.total || 0
			};
		} catch (error) {
			console.error('[ProjectModel.count] 计数出错:', error);
			// 返回默认值而非抛出错误，确保应用继续运行
			return {
				code: -1,
				total: 0,
				count: 0,
				error: error.message
			};
		}
	}
	
	/**
	 * 静态count方法，适应云开发环境
	 * @param {Object} where 查询条件
	 * @returns {Number|Object} 计数结果
	 */
	static async count(where = {}) {
		console.log('[ProjectModel.static.count] 开始计数, 条件:', where);
		try {
			// 使用固定的集合名，与insert方法保持一致
			const COLLECTION_NAME = "plm_research_project";
			
			const db = cloudBase.getCloud().database();
			const collection = db.collection(COLLECTION_NAME);
			
			// 使用云开发标准的count方法
			const countResult = await collection.where(where).count();
			console.log('[ProjectModel.static.count] 计数结果:', countResult);
			
			// 调用者可能期望一个简单数字或对象，提供兼容的返回
			return countResult.total || 0;
		} catch (error) {
			console.error('[ProjectModel.static.count] 计数出错:', error);
			// 返回0而非抛出错误，确保应用继续运行
			return 0;
		}
	}

	/**
	 * 重写clearDirtyData方法，允许所有字段通过
	 * @param {Object} data 数据对象
	 * @returns {Object} 处理后的数据对象
	 * @static
	 */
	static clearDirtyData(data) {
		// 记录原始字段数量
		const originalKeys = Object.keys(data);
		console.log('[ProjectModel.clearDirtyData] 原始字段数量:', originalKeys.length);
		
		// 仅过滤敏感字段，保留其他业务数据
		const sensitiveFields = ['_openid', 'PASSWORD', 'AUTH_TOKEN', 'ADMIN_FLAG'];
		for (const key of sensitiveFields) {
			if (data.hasOwnProperty(key)) {
				delete data[key];
				console.log(`[ProjectModel.clearDirtyData] 删除敏感字段: ${key}`);
			}
		}
		
		// 记录未在schema中定义的字段，但不删除它们
		const undefinedKeys = [];
		for (let key in data) {
			if (!this.DB_STRUCTURE.hasOwnProperty(key) && !key.includes('.')) {
				undefinedKeys.push(key);
			}
		}
		
		// 输出日志
		if (undefinedKeys.length > 0) {
			console.log('[ProjectModel.clearDirtyData] 允许通过的未定义字段:', undefinedKeys.join(', '));
		}
		
		// 返回处理后的数据
		return data;
	}

	/**
	 * 重写clearCreateData方法，跳过脏数据检查
	 * @param {Object} data 数据对象
	 * @returns {Object} 处理后的数据对象
	 * @static
	 */
	static clearCreateData(data) {
		console.log('[ProjectModel.clearCreateData] 原始数据字段数: ', Object.keys(data).length);
		console.log('[ProjectModel.clearCreateData] 原始数据字段: ', Object.keys(data).join(', '));
		
		// 创建数据副本以避免修改原始数据
		const processedData = { ...data };
		
		// 初始化extData对象
		if (!processedData.extData) {
			processedData.extData = {};
		}
		
		// 分离核心字段和扩展字段
		const coreFields = new Set(this.CORE_FIELDS);
		const systemFields = new Set(['_id', '_pid', 'createTime', 'updateTime', 'stateTime']);
		
		// 遍历所有字段
		for (const key in processedData) {
			// 跳过extData字段本身
			if (key === 'extData') continue;
			
			// 如果不是核心字段且不是系统字段，移动到extData中
			if (!coreFields.has(key) && !systemFields.has(key) && !key.startsWith('_')) {
				processedData.extData[key] = processedData[key];
				delete processedData[key];
			}
		}
		
		let dbStructure = Model.converDBStructure(this.DB_STRUCTURE);
		
		// 处理必填字段和默认值
		for (let key in dbStructure) {
			if (!processedData.hasOwnProperty(key)) {
				if (dbStructure[key].required) {
					if (util.isDefined(dbStructure[key].defVal)) {
						processedData[key] = dbStructure[key].defVal;
					} else {
						switch (dbStructure[key].type.toLowerCase()) {
							case 'string':
								processedData[key] = '';
								break;
							case 'int':
							case 'float':
								processedData[key] = 0;
								break;
							case 'bool':
								processedData[key] = false;
								break;
							case 'array':
								processedData[key] = [];
								break;
							case 'object':
								processedData[key] = {};
								break;
							default:
								processedData[key] = '';
						}
					}
				} else if (util.isDefined(dbStructure[key].defVal)) {
					processedData[key] = dbStructure[key].defVal;
				}
			}
		}
		
		// 数据类型转换
		for (let key in processedData) {
			if (key === 'extData') continue;
			
			if (dbStructure.hasOwnProperty(key)) {
				let type = dbStructure[key].type.toLowerCase();
				switch (type) {
					case 'string':
						processedData[key] = String(processedData[key]);
						break;
					case 'bool':
						break;
					case 'float':
					case 'int':
						processedData[key] = Number(processedData[key]);
						break;
					case 'array':
						if (!Array.isArray(processedData[key])) {
							processedData[key] = [];
						}
						break;
					case 'object':
						if (processedData[key] === undefined || processedData[key] === null) {
							processedData[key] = {};
						} else if (typeof processedData[key] !== 'object') {
							processedData[key] = {};
						}
						break;
				}
			}
		}
		
		// 记录处理后的字段数量
		const coreFieldCount = Object.keys(processedData).filter(k => k !== 'extData').length;
		const extFieldCount = Object.keys(processedData.extData).length;
		
		console.log('[ProjectModel.clearCreateData] 处理后核心字段数: ', coreFieldCount);
		console.log('[ProjectModel.clearCreateData] 扩展字段数: ', extFieldCount);
		console.log('[ProjectModel.clearCreateData] 核心字段列表: ', Object.keys(processedData).filter(k => k !== 'extData').join(', '));
		console.log('[ProjectModel.clearCreateData] 扩展字段列表: ', Object.keys(processedData.extData).join(', '));
		
		return processedData;
	}

	/**
	 * 重写clearEditData方法，支持扩展字段处理
	 * @param {Object} data 数据对象
	 * @returns {Object} 处理后的数据对象
	 * @static
	 */
	static clearEditData(data) {
		console.log('[ProjectModel.clearEditData] 原始数据字段数: ', Object.keys(data).length);
		console.log('[ProjectModel.clearEditData] 原始数据字段: ', Object.keys(data).join(', '));
		
		// 创建数据副本
		const processedData = { ...data };
		
		// 确保extData存在
		if (!processedData.extData) {
			processedData.extData = {};
		}
		
		// 分离核心字段和扩展字段
		for (const key in processedData) {
			// 跳过extData字段本身
			if (key === 'extData') continue;
			
			// 如果不是核心字段且不是以下划线开头的系统字段，移动到extData中
			if (!this.CORE_FIELDS.includes(key) && !key.startsWith('_')) {
				processedData.extData[key] = processedData[key];
				delete processedData[key];
			}
		}
		
		console.log('[ProjectModel.clearEditData] 处理后核心字段数: ', 
			Object.keys(processedData).filter(k => k !== 'extData').length);
		console.log('[ProjectModel.clearEditData] 扩展字段数: ', 
			Object.keys(processedData.extData).length);
		
		return processedData;
	}

	/**
	 * 静态版本的insert方法，直接调用数据库接口
	 * @param {Object} data 要插入的数据
	 * @returns {Promise<string>} 插入记录的ID
	 */
	static async insert(data) {
		console.log('[ProjectModel.static.insert] 开始插入数据');
		
		try {
			// 记录原始字段数量
			const originalFields = Object.keys(data);
			console.log('[ProjectModel.static.insert] 原始字段数:', originalFields.length);
			
			// 数据清洗前的原始字段
			const beforeCleanFields = [...originalFields];
			console.log('[ProjectModel.static.insert] 数据清洗前字段:', beforeCleanFields.join(', '));
			
			// 使用clearCreateData进行数据清洗
			console.log('[ProjectModel.static.insert] 开始数据清洗...');
			const processedData = this.clearCreateData(data);
			console.log('[ProjectModel.static.insert] 数据清洗完成');
			
			// 记录清洗后的字段数量
			const processedFields = Object.keys(processedData);
			const extFields = processedData.extData ? Object.keys(processedData.extData) : [];
			
			console.log('[ProjectModel.static.insert] 清洗后核心字段数:', 
				processedFields.filter(k => k !== 'extData').length);
			console.log('[ProjectModel.static.insert] 扩展字段数:', extFields.length);
			
			// 创建模型实例
			console.log('[ProjectModel.static.insert] 创建模型实例...');
				const model = new ProjectModel();
			console.log('[ProjectModel.static.insert] 模型实例创建成功');
			
			// 添加标记，避免递归调用
			processedData.__fromStatic = true;
			
			// 执行插入操作
			console.log('[ProjectModel.static.insert] 调用实例插入方法...');
			try {
				const result = await model.insert(processedData);
				console.log('[ProjectModel.static.insert] 插入操作成功，ID:', result);
				return result;
			} catch (directError) {
				console.error('[ProjectModel.static.insert] 直接插入操作失败:', directError.message);
				console.error('[ProjectModel.static.insert] 错误详情:', directError);
				
				// 尝试备用插入方法
				console.log('[ProjectModel.static.insert] 尝试备用插入方法...');
				try {
					const db = cloudBase.getCloud().database();
					const collection = db.collection('plm_research_project');
					const addResult = await collection.add({ data: processedData });
					
					if (addResult && addResult._id) {
						console.log('[ProjectModel.static.insert] 备用插入成功，ID:', addResult._id);
						return addResult._id;
					} else {
						throw new Error('备用插入未返回ID');
					}
				} catch (backupError) {
					console.error('[ProjectModel.static.insert] 备用插入也失败:', backupError.message);
					throw backupError;
				}
			}
		} catch (err) {
			console.error('[ProjectModel.static.insert] 插入数据失败:', err.message);
			console.error('[ProjectModel.static.insert] 错误堆栈:', err.stack || '无堆栈信息');
			throw err;
		}
	}

	/**
	 * 获取项目详情
	 * @param {String} id 项目ID
	 * @returns {Promise<Object>} 项目详情数据
	 */
	async getProjectDetail(id) {
		return await this.getOne({ _id: id });
	}

	/**
	 * 获取项目详情（静态方法）
	 * @param {string} id 项目ID
	 * @returns 项目详情
	 */
	static async getProjectDetail(id) {
		return await this.getOne(id);
	}

	/**
	 * 更新项目数据（支持扩展字段更新）
	 * @param {string} id 项目ID
	 * @param {Object} data 要更新的数据
	 * @returns {Promise<boolean>} 更新结果
	 */
	static async updateProject(id, data) {
		console.log('[ProjectModel.updateProject] 开始更新项目, ID:', id);
		console.log('[ProjectModel.updateProject] 更新数据字段数:', Object.keys(data).length);
		
		try {
			// 区分核心字段和扩展字段
			const coreFields = {};
			const extFields = {};
			
			for (const key in data) {
				if (this.CORE_FIELDS.includes(key)) {
					coreFields[key] = data[key];
				} else if (key !== 'extData') {
					extFields[key] = data[key];
				}
			}
			
			console.log('[ProjectModel.updateProject] 核心字段数:', Object.keys(coreFields).length);
			console.log('[ProjectModel.updateProject] 扩展字段数:', Object.keys(extFields).length);
			
			// 获取数据库引用
			const COLLECTION_NAME = "plm_research_project";
			const db = cloudBase.getCloud().database();
			const collection = db.collection(COLLECTION_NAME);
			
			// 如果有扩展字段需要更新
			if (Object.keys(extFields).length > 0) {
				// 获取当前项目数据
				const currentProject = await this.getOne(id);
				
				if (!currentProject) {
					console.error('[ProjectModel.updateProject] 找不到要更新的项目');
					return false;
				}
			
				// 获取当前的extData或创建新的
				const currentExtData = (currentProject.extData || {});
				
				// 将新的扩展字段合并到当前extData
				const mergedExtData = {
					...currentExtData,
					...extFields
				};
				
				// 添加extData到核心字段更新中
				coreFields.extData = mergedExtData;
			}
			
			// 更新时间字段
			if (!coreFields.updateTime) {
				coreFields.updateTime = Math.floor(Date.now() / 1000);
			}
			
			// 执行更新
			const result = await collection.doc(id).update({
				data: coreFields
			});
			
			console.log('[ProjectModel.updateProject] 更新结果:', result);
			
			if (result && result.stats && result.stats.updated) {
				return true;
			}
			
			return false;
		} catch (err) {
			console.error('[ProjectModel.updateProject] 更新项目失败:', err.message);
			return false;
		}
	}

	/**
	 * 重写更新方法，添加数据完整性检查和监控
	 */
	static async update(id, data) {
		console.log('[ProjectModel.update] 开始更新数据, ID:', id);
		
		try {
			// 记录原始字段
			const originalFields = Object.keys(data);
			
			// 数据清洗前的原始字段
			const beforeCleanFields = [...originalFields];
			
			// 使用clearEditData进行数据清洗
			const processedData = this.clearEditData(data);
			
			// 记录清洗后的字段
			const processedFields = Object.keys(processedData);
			const extFields = processedData.extData ? Object.keys(processedData.extData) : [];
			
			console.log('[ProjectModel.update] 清洗后核心字段数:', 
				processedFields.filter(k => k !== 'extData').length);
			console.log('[ProjectModel.update] 扩展字段数:', extFields.length);
			
			// 使用性能监控包装器执行更新操作
			return await dataMonitor.monitorPerformance(
				async () => {
					// 实际更新操作
					const result = await super.update(id, processedData);
					
					console.log('[ProjectModel.update] 数据更新成功, ID:', id);
					
					return result;
				},
				dataMonitor.OPERATION_TYPES.UPDATE,
				'plm_research_project',
				{ id, ...processedData },
				{ 
					originalFieldCount: originalFields.length,
					processedFieldCount: processedFields.length,
					extFieldCount: extFields.length
				}
			);
		} catch (err) {
			console.error('[ProjectModel.update] 更新数据失败:', err);
			
			// 记录错误
			await dataMonitor.logOperation(
				dataMonitor.OPERATION_TYPES.UPDATE,
				'plm_research_project',
				{ id, ...data },
				{ 
					success: false,
					error: err 
				}
			);
			
			throw err;
		}
	}

	/**
	 * 重写查询方法，添加性能监控
	 */
	static async getList(where, fields = '*', orderBy = {}, page = 1, size = 10) {
		try {
			console.log('[ProjectModel.getList] 开始查询, 条件:', JSON.stringify(where));
			
			// 处理扩展字段查询条件
			const processedWhere = this.buildExtFieldQuery(where);
			
			// 获取云数据库实例
			const COLLECTION_NAME = "plm_research_project";
			const db = cloudBase.getCloud().database();
			const collection = db.collection(COLLECTION_NAME);
			
			// 构建查询对象
			let dbQuery = collection.where(processedWhere);
			
			// 设置排序
			if (orderBy && typeof orderBy === 'object') {
				for (const key in orderBy) {
					const direction = orderBy[key].toLowerCase() === 'desc' ? 'desc' : 'asc';
					dbQuery = dbQuery.orderBy(key, direction);
				}
			}
			
			// 设置分页
			const skip = (page - 1) * size;
			dbQuery = dbQuery.skip(skip).limit(size);
			
			// 执行查询
			const result = await dbQuery.get();
			
			console.log(`[ProjectModel.getList] 查询成功，结果数量:`, result.data ? result.data.length : 0);
			
			// 处理结果 - 展开扩展字段
			const list = result.data ? result.data.map(item => this.getFullProjectData(item)) : [];
			
			// 返回结果
			return {
				list,
				total: list.length,
				page,
				size
			};
		} catch (err) {
			console.error('[ProjectModel.getList] 查询数据失败:', err);
			
			// 返回空结果而不是抛出错误，防止前端崩溃
			return {
				list: [],
				total: 0,
				page,
				size
			};
		}
	}

	/**
	 * 重写单个查询方法，添加性能监控
	 */
	static async getOne(where, fields = '*') {
		try {
			// 确定查询条件类型
			const isIdQuery = typeof where === 'string';
			
			// 处理扩展字段查询条件
			const processedWhere = isIdQuery ? where : this.buildExtFieldQuery(where);
			
			// 使用性能监控包装器执行查询操作
			const result = await dataMonitor.monitorPerformance(
				async () => {
					return await super.getOne(processedWhere, fields);
				},
				dataMonitor.OPERATION_TYPES.QUERY,
				'plm_research_project',
				{ where: processedWhere, fields },
				{ queryType: 'one' }
			);
			
			// 获取完整数据（展开扩展字段到顶层）
			return this.getFullProjectData(result);
		} catch (err) {
			console.error('[ProjectModel.getOne] 查询数据失败:', err);
			
			// 记录错误
			await dataMonitor.logOperation(
				dataMonitor.OPERATION_TYPES.QUERY,
				'plm_research_project',
				{ where, fields },
				{ 
					success: false,
					error: err,
					queryType: 'one'
				}
			);
			
			throw err;
		}
	}
}

module.exports = ProjectModel; 